home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / misc / fcxref.lha / FCXRef / Src / head.c < prev    next >
C/C++ Source or Header  |  1999-02-08  |  40KB  |  1,648 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* Scanner skeleton version:
  4.  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  10.  
  11. #include <stdio.h>
  12.  
  13.  
  14. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15. #ifdef c_plusplus
  16. #ifndef __cplusplus
  17. #define __cplusplus
  18. #endif
  19. #endif
  20.  
  21.  
  22. #ifdef __cplusplus
  23.  
  24. #include <stdlib.h>
  25. #include <unistd.h>
  26.  
  27. /* Use prototypes in function declarations. */
  28. #define YY_USE_PROTOS
  29.  
  30. /* The "const" storage-class-modifier is valid. */
  31. #define YY_USE_CONST
  32.  
  33. #else    /* ! __cplusplus */
  34.  
  35. #if __STDC__
  36.  
  37. #define YY_USE_PROTOS
  38. #define YY_USE_CONST
  39.  
  40. #endif    /* __STDC__ */
  41. #endif    /* ! __cplusplus */
  42.  
  43. #ifdef __TURBOC__
  44.  #pragma warn -rch
  45.  #pragma warn -use
  46. #include <io.h>
  47. #include <stdlib.h>
  48. #define YY_USE_CONST
  49. #define YY_USE_PROTOS
  50. #endif
  51.  
  52. #ifdef YY_USE_CONST
  53. #define yyconst const
  54. #else
  55. #define yyconst
  56. #endif
  57.  
  58.  
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  64.  
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  67.  
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74.  
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  80.  
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83.  * compatibility.
  84.  */
  85. #define YY_START ((yy_start - 1) / 2)
  86. #define YYSTATE YY_START
  87.  
  88. /* Action number for EOF rule of a given start state. */
  89. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90.  
  91. /* Special action meaning "start processing a new file". */
  92. #define YY_NEW_FILE yyrestart( yyin )
  93.  
  94. #define YY_END_OF_BUFFER_CHAR 0
  95.  
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  98.  
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  100.  
  101. extern int yyleng;
  102. extern FILE *yyin, *yyout;
  103.  
  104. #define EOB_ACT_CONTINUE_SCAN 0
  105. #define EOB_ACT_END_OF_FILE 1
  106. #define EOB_ACT_LAST_MATCH 2
  107.  
  108. /* The funky do-while in the following #define is used to turn the definition
  109.  * int a single C statement (which needs a semi-colon terminator).  This
  110.  * avoids problems with code like:
  111.  *
  112.  *     if ( condition_holds )
  113.  *        yyless( 5 );
  114.  *    else
  115.  *        do_something_else();
  116.  *
  117.  * Prior to using the do-while the compiler would get upset at the
  118.  * "else" because it interpreted the "if" statement as being all
  119.  * done when it reached the ';' after the yyless() call.
  120.  */
  121.  
  122. /* Return all but the first 'n' matched characters back to the input stream. */
  123.  
  124. #define yyless(n) \
  125.     do \
  126.         { \
  127.         /* Undo effects of setting up yytext. */ \
  128.         *yy_cp = yy_hold_char; \
  129.         YY_RESTORE_YY_MORE_OFFSET \
  130.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  131.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  132.         } \
  133.     while ( 0 )
  134.  
  135. #define unput(c) yyunput( c, yytext_ptr )
  136.  
  137. /* The following is because we cannot portably get our hands on size_t
  138.  * (without autoconf's help, which isn't available because we want
  139.  * flex-generated scanners to compile on their own).
  140.  */
  141. typedef unsigned int yy_size_t;
  142.  
  143.  
  144. struct yy_buffer_state
  145.     {
  146.     FILE *yy_input_file;
  147.  
  148.     char *yy_ch_buf;        /* input buffer */
  149.     char *yy_buf_pos;        /* current position in input buffer */
  150.  
  151.     /* Size of input buffer in bytes, not including room for EOB
  152.      * characters.
  153.      */
  154.     yy_size_t yy_buf_size;
  155.  
  156.     /* Number of characters read into yy_ch_buf, not including EOB
  157.      * characters.
  158.      */
  159.     int yy_n_chars;
  160.  
  161.     /* Whether we "own" the buffer - i.e., we know we created it,
  162.      * and can realloc() it to grow it, and should free() it to
  163.      * delete it.
  164.      */
  165.     int yy_is_our_buffer;
  166.  
  167.     /* Whether this is an "interactive" input source; if so, and
  168.      * if we're using stdio for input, then we want to use getc()
  169.      * instead of fread(), to make sure we stop fetching input after
  170.      * each newline.
  171.      */
  172.     int yy_is_interactive;
  173.  
  174.     /* Whether we're considered to be at the beginning of a line.
  175.      * If so, '^' rules will be active on the next match, otherwise
  176.      * not.
  177.      */
  178.     int yy_at_bol;
  179.  
  180.     /* Whether to try to fill the input buffer when we reach the
  181.      * end of it.
  182.      */
  183.     int yy_fill_buffer;
  184.  
  185.     int yy_buffer_status;
  186. #define YY_BUFFER_NEW 0
  187. #define YY_BUFFER_NORMAL 1
  188.     /* When an EOF's been seen but there's still some text to process
  189.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  190.      * shouldn't try reading from the input source any more.  We might
  191.      * still have a bunch of tokens to match, though, because of
  192.      * possible backing-up.
  193.      *
  194.      * When we actually see the EOF, we change the status to "new"
  195.      * (via yyrestart()), so that the user can continue scanning by
  196.      * just pointing yyin at a new input file.
  197.      */
  198. #define YY_BUFFER_EOF_PENDING 2
  199.     };
  200.  
  201. static YY_BUFFER_STATE yy_current_buffer = 0;
  202.  
  203. /* We provide macros for accessing buffer states in case in the
  204.  * future we want to put the buffer states in a more general
  205.  * "scanner state".
  206.  */
  207. #define YY_CURRENT_BUFFER yy_current_buffer
  208.  
  209.  
  210. /* yy_hold_char holds the character lost when yytext is formed. */
  211. static char yy_hold_char;
  212.  
  213. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  214.  
  215.  
  216. int yyleng;
  217.  
  218. /* Points to current character in buffer. */
  219. static char *yy_c_buf_p = (char *) 0;
  220. static int yy_init = 1;        /* whether we need to initialize */
  221. static int yy_start = 0;    /* start state number */
  222.  
  223. /* Flag which is used to allow yywrap()'s to do buffer switches
  224.  * instead of setting up a fresh yyin.  A bit of a hack ...
  225.  */
  226. static int yy_did_buffer_switch_on_eof;
  227.  
  228. void yyrestart YY_PROTO(( FILE *input_file ));
  229.  
  230. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  231. void yy_load_buffer_state YY_PROTO(( void ));
  232. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  233. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  234. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  235. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  236. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  237.  
  238. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  239. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
  240. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  241.  
  242. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  243. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  244. static void yy_flex_free YY_PROTO(( void * ));
  245.  
  246. #define yy_new_buffer yy_create_buffer
  247.  
  248. #define yy_set_interactive(is_interactive) \
  249.     { \
  250.     if ( ! yy_current_buffer ) \
  251.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  252.     yy_current_buffer->yy_is_interactive = is_interactive; \
  253.     }
  254.  
  255. #define yy_set_bol(at_bol) \
  256.     { \
  257.     if ( ! yy_current_buffer ) \
  258.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  259.     yy_current_buffer->yy_at_bol = at_bol; \
  260.     }
  261.  
  262. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  263.  
  264. typedef unsigned char YY_CHAR;
  265. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  266. typedef int yy_state_type;
  267. extern char *yytext;
  268. #define yytext_ptr yytext
  269.  
  270. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  271. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  272. static int yy_get_next_buffer YY_PROTO(( void ));
  273. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  274.  
  275. /* Done after the current pattern has been matched and before the
  276.  * corresponding action - sets up yytext.
  277.  */
  278. #define YY_DO_BEFORE_ACTION \
  279.     yytext_ptr = yy_bp; \
  280.     yyleng = (int) (yy_cp - yy_bp); \
  281.     yy_hold_char = *yy_cp; \
  282.     *yy_cp = '\0'; \
  283.     yy_c_buf_p = yy_cp;
  284.  
  285. #define YY_NUM_RULES 13
  286. #define YY_END_OF_BUFFER 14
  287. static yyconst short int yy_accept[44] =
  288.     {   0,
  289.         0,    0,    0,    0,    0,    0,    6,    6,   14,   12,
  290.        12,   11,   12,   12,   13,    3,   10,    9,    4,    5,
  291.         6,    7,    8,    0,    0,    0,    0,    0,    3,    4,
  292.         6,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  293.         2,    1,    0
  294.     } ;
  295.  
  296. static yyconst int yy_ec[256] =
  297.     {   0,
  298.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  299.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  300.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  301.         1,    2,    1,    2,    4,    1,    1,    1,    1,    1,
  302.         1,    1,    1,    1,    1,    1,    1,    5,    5,    5,
  303.         5,    5,    5,    5,    5,    5,    5,    1,    1,    1,
  304.         1,    1,    1,    1,    5,    5,    5,    5,    5,    5,
  305.         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
  306.         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
  307.         1,    1,    1,    1,    5,    1,    5,    5,    6,    7,
  308.  
  309.         8,    9,    5,    5,   10,    5,    5,    5,    5,   11,
  310.         5,    5,    5,   12,   13,   14,   15,    5,    5,    5,
  311.         5,    5,   16,    1,    1,    1,    1,    1,    1,    1,
  312.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  313.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  314.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  315.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  316.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  317.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  318.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  319.  
  320.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  321.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  322.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  323.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  324.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  325.         1,    1,    1,    1,    1
  326.     } ;
  327.  
  328. static yyconst int yy_meta[17] =
  329.     {   0,
  330.         1,    1,    1,    1,    2,    2,    2,    2,    2,    2,
  331.         2,    2,    2,    2,    2,    1
  332.     } ;
  333.  
  334. static yyconst short int yy_base[50] =
  335.     {   0,
  336.         0,   12,   25,   41,   57,   73,   88,  103,   36,  140,
  337.       118,  140,   28,   20,  140,    0,  140,  140,    0,  140,
  338.        31,  140,  140,    0,   25,   17,   22,   12,    0,    0,
  339.        21,   13,    6,   10,   13,    7,    3,    3,    8,    7,
  340.         6,    5,  140,  131,  133,  135,  137,    4,    3
  341.     } ;
  342.  
  343. static yyconst short int yy_def[50] =
  344.     {   0,
  345.        44,   44,   45,   45,   46,   46,   47,   47,   43,   43,
  346.        43,   43,   43,   43,   43,   48,   43,   43,   49,   43,
  347.        43,   43,   43,   11,   43,   43,   43,   43,   48,   49,
  348.        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
  349.        43,   43,    0,   43,   43,   43,   43,   43,   43
  350.     } ;
  351.  
  352. static yyconst short int yy_nxt[157] =
  353.     {   0,
  354.        43,   11,   12,   13,   30,   29,   42,   41,   42,   41,
  355.        40,   43,   14,   11,   12,   13,   39,   38,   37,   36,
  356.        35,   34,   31,   33,   14,   15,   15,   15,   15,   32,
  357.        28,   27,   31,   28,   27,   43,   43,   43,   43,   43,
  358.        15,   15,   15,   15,   15,   43,   43,   43,   43,   43,
  359.        43,   43,   43,   43,   43,   43,   15,   17,   17,   18,
  360.        17,   43,   43,   43,   43,   43,   43,   43,   43,   43,
  361.        43,   43,   17,   17,   17,   18,   17,   43,   43,   43,
  362.        43,   43,   43,   43,   43,   43,   43,   43,   17,   21,
  363.        22,   43,   43,   43,   43,   43,   43,   43,   43,   43,
  364.  
  365.        43,   43,   43,   23,   21,   22,   43,   43,   43,   43,
  366.        43,   43,   43,   43,   43,   43,   43,   43,   23,   24,
  367.        43,   25,   43,   43,   43,   43,   43,   43,   43,   43,
  368.        26,   10,   10,   16,   16,   19,   19,   20,   20,    9,
  369.        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
  370.        43,   43,   43,   43,   43,   43
  371.     } ;
  372.  
  373. static yyconst short int yy_chk[157] =
  374.     {   0,
  375.         0,    1,    1,    1,   49,   48,   42,   41,   40,   39,
  376.        38,    0,    1,    2,    2,    2,   37,   36,   35,   34,
  377.        33,   32,   31,   28,    2,    3,    3,    3,    3,   27,
  378.        26,   25,   21,   14,   13,    9,    0,    0,    0,    0,
  379.         3,    4,    4,    4,    4,    0,    0,    0,    0,    0,
  380.         0,    0,    0,    0,    0,    0,    4,    5,    5,    5,
  381.         5,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  382.         0,    0,    5,    6,    6,    6,    6,    0,    0,    0,
  383.         0,    0,    0,    0,    0,    0,    0,    0,    6,    7,
  384.         7,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  385.  
  386.         0,    0,    0,    7,    8,    8,    0,    0,    0,    0,
  387.         0,    0,    0,    0,    0,    0,    0,    0,    8,   11,
  388.         0,   11,    0,    0,    0,    0,    0,    0,    0,    0,
  389.        11,   44,   44,   45,   45,   46,   46,   47,   47,   43,
  390.        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
  391.        43,   43,   43,   43,   43,   43
  392.     } ;
  393.  
  394. static yy_state_type yy_last_accepting_state;
  395. static char *yy_last_accepting_cpos;
  396.  
  397. /* The intent behind this definition is that it'll catch
  398.  * any uses of REJECT which flex missed.
  399.  */
  400. #define REJECT reject_used_but_not_detected
  401. #define yymore() yymore_used_but_not_detected
  402. #define YY_MORE_ADJ 0
  403. #define YY_RESTORE_YY_MORE_OFFSET
  404. char *yytext;
  405. #line 1 "head.l"
  406. #define INITIAL 0
  407. #line 2 "head.l"
  408. #include <stdio.h>
  409. #include <stdlib.h>
  410. #include <ctype.h>
  411.  
  412. extern int AddFunc(char *file, char *func,int linenum);
  413. extern int opt_struct;
  414.  
  415. char *actfile;
  416. int lineno;
  417. char struname[1024];
  418. int struline;
  419.  
  420. #define xdefine 1
  421.  
  422. #define xstruct 2
  423.  
  424. #define ins 3
  425.  
  426.  
  427. /* Macros after this point can all be overridden by user definitions in
  428.  * section 1.
  429.  */
  430.  
  431. #ifndef YY_SKIP_YYWRAP
  432. #ifdef __cplusplus
  433. extern "C" int yywrap YY_PROTO(( void ));
  434. #else
  435. extern int yywrap YY_PROTO(( void ));
  436. #endif
  437. #endif
  438.  
  439. #ifndef YY_NO_UNPUT
  440. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  441. #endif
  442.  
  443. #ifndef yytext_ptr
  444. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  445. #endif
  446.  
  447. #ifdef YY_NEED_STRLEN
  448. static int yy_flex_strlen YY_PROTO(( yyconst char * ));
  449. #endif
  450.  
  451. #ifndef YY_NO_INPUT
  452. #ifdef __cplusplus
  453. static int yyinput YY_PROTO(( void ));
  454. #else
  455. static int input YY_PROTO(( void ));
  456. #endif
  457. #endif
  458.  
  459. #if YY_STACK_USED
  460. static int yy_start_stack_ptr = 0;
  461. static int yy_start_stack_depth = 0;
  462. static int *yy_start_stack = 0;
  463. #ifndef YY_NO_PUSH_STATE
  464. static void yy_push_state YY_PROTO(( int new_state ));
  465. #endif
  466. #ifndef YY_NO_POP_STATE
  467. static void yy_pop_state YY_PROTO(( void ));
  468. #endif
  469. #ifndef YY_NO_TOP_STATE
  470. static int yy_top_state YY_PROTO(( void ));
  471. #endif
  472.  
  473. #else
  474. #define YY_NO_PUSH_STATE 1
  475. #define YY_NO_POP_STATE 1
  476. #define YY_NO_TOP_STATE 1
  477. #endif
  478.  
  479. #ifdef YY_MALLOC_DECL
  480. YY_MALLOC_DECL
  481. #else
  482. #if __STDC__
  483. #ifndef __cplusplus
  484. #include <stdlib.h>
  485. #endif
  486. #else
  487. /* Just try to get by without declaring the routines.  This will fail
  488.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  489.  * or sizeof(void*) != sizeof(int).
  490.  */
  491. #endif
  492. #endif
  493.  
  494. /* Amount of stuff to slurp up with each read. */
  495. #ifndef YY_READ_BUF_SIZE
  496. #define YY_READ_BUF_SIZE 8192
  497. #endif
  498.  
  499. /* Copy whatever the last rule matched to the standard output. */
  500.  
  501. #ifndef ECHO
  502. /* This used to be an fputs(), but since the string might contain NUL's,
  503.  * we now use fwrite().
  504.  */
  505. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  506. #endif
  507.  
  508. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  509.  * is returned in "result".
  510.  */
  511. #ifndef YY_INPUT
  512. #define YY_INPUT(buf,result,max_size) \
  513.     if ( yy_current_buffer->yy_is_interactive ) \
  514.         { \
  515.         int c = '*', n; \
  516.         for ( n = 0; n < max_size && \
  517.                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  518.             buf[n] = (char) c; \
  519.         if ( c == '\n' ) \
  520.             buf[n++] = (char) c; \
  521.         if ( c == EOF && ferror( yyin ) ) \
  522.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  523.         result = n; \
  524.         } \
  525.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  526.           && ferror( yyin ) ) \
  527.         YY_FATAL_ERROR( "input in flex scanner failed" );
  528. #endif
  529.  
  530. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  531.  * we don't want an extra ';' after the "return" because that will cause
  532.  * some compilers to complain about unreachable statements.
  533.  */
  534. #ifndef yyterminate
  535. #define yyterminate() return YY_NULL
  536. #endif
  537.  
  538. /* Number of entries by which start-condition stack grows. */
  539. #ifndef YY_START_STACK_INCR
  540. #define YY_START_STACK_INCR 25
  541. #endif
  542.  
  543. /* Report a fatal error. */
  544. #ifndef YY_FATAL_ERROR
  545. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  546. #endif
  547.  
  548. /* Default declaration of generated scanner - a define so the user can
  549.  * easily add parameters.
  550.  */
  551. #ifndef YY_DECL
  552. #define YY_DECL int yylex YY_PROTO(( void ))
  553. #endif
  554.  
  555. /* Code executed at the beginning of each rule, after yytext and yyleng
  556.  * have been set up.
  557.  */
  558. #ifndef YY_USER_ACTION
  559. #define YY_USER_ACTION
  560. #endif
  561.  
  562. /* Code executed at the end of each rule. */
  563. #ifndef YY_BREAK
  564. #define YY_BREAK break;
  565. #endif
  566.  
  567. #define YY_RULE_SETUP \
  568.     YY_USER_ACTION
  569.  
  570. YY_DECL
  571.     {
  572.     register yy_state_type yy_current_state;
  573.     register char *yy_cp, *yy_bp;
  574.     register int yy_act;
  575.  
  576. #line 20 "head.l"
  577.  
  578.  
  579.  
  580.     if ( yy_init )
  581.         {
  582.         yy_init = 0;
  583.  
  584. #ifdef YY_USER_INIT
  585.         YY_USER_INIT;
  586. #endif
  587.  
  588.         if ( ! yy_start )
  589.             yy_start = 1;    /* first start state */
  590.  
  591.         if ( ! yyin )
  592.             yyin = stdin;
  593.  
  594.         if ( ! yyout )
  595.             yyout = stdout;
  596.  
  597.         if ( ! yy_current_buffer )
  598.             yy_current_buffer =
  599.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  600.  
  601.         yy_load_buffer_state();
  602.         }
  603.  
  604.     while ( 1 )        /* loops until end-of-file is reached */
  605.         {
  606.         yy_cp = yy_c_buf_p;
  607.  
  608.         /* Support of yytext. */
  609.         *yy_cp = yy_hold_char;
  610.  
  611.         /* yy_bp points to the position in yy_ch_buf of the start of
  612.          * the current run.
  613.          */
  614.         yy_bp = yy_cp;
  615.  
  616.         yy_current_state = yy_start;
  617. yy_match:
  618.         do
  619.             {
  620.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  621.             if ( yy_accept[yy_current_state] )
  622.                 {
  623.                 yy_last_accepting_state = yy_current_state;
  624.                 yy_last_accepting_cpos = yy_cp;
  625.                 }
  626.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  627.                 {
  628.                 yy_current_state = (int) yy_def[yy_current_state];
  629.                 if ( yy_current_state >= 44 )
  630.                     yy_c = yy_meta[(unsigned int) yy_c];
  631.                 }
  632.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  633.             ++yy_cp;
  634.             }
  635.         while ( yy_base[yy_current_state] != 140 );
  636.  
  637. yy_find_action:
  638.         yy_act = yy_accept[yy_current_state];
  639.         if ( yy_act == 0 )
  640.             { /* have to back up */
  641.             yy_cp = yy_last_accepting_cpos;
  642.             yy_current_state = yy_last_accepting_state;
  643.             yy_act = yy_accept[yy_current_state];
  644.             }
  645.  
  646.         YY_DO_BEFORE_ACTION;
  647.  
  648.  
  649. do_action:    /* This label is used only to access EOF actions. */
  650.  
  651.  
  652.         switch ( yy_act )
  653.     { /* beginning of action switch */
  654.             case 0: /* must back up */
  655.             /* undo the effects of YY_DO_BEFORE_ACTION */
  656.             *yy_cp = yy_hold_char;
  657.             yy_cp = yy_last_accepting_cpos;
  658.             yy_current_state = yy_last_accepting_state;
  659.             goto yy_find_action;
  660.  
  661. case 1:
  662. YY_RULE_SETUP
  663. #line 22 "head.l"
  664. { BEGIN(xdefine); }
  665.     YY_BREAK
  666. case 2:
  667. YY_RULE_SETUP
  668. #line 23 "head.l"
  669. {
  670.                             if(opt_struct!=0) BEGIN(xstruct);
  671.                             }
  672.     YY_BREAK
  673. case 3:
  674. YY_RULE_SETUP
  675. #line 27 "head.l"
  676. {
  677.                         int l;
  678.                         l=strlen(yytext)-1;
  679.                         if(yytext[l]!='H'&&yytext[l-1]!='_') {
  680.                             AddFunc(actfile,yytext,lineno);
  681.                             }
  682.                         BEGIN(INITIAL);
  683.                         }
  684.     YY_BREAK
  685. case 4:
  686. YY_RULE_SETUP
  687. #line 35 "head.l"
  688. {
  689.                         struline=lineno;
  690.                         if(strlen(yytext)<1024) strcpy(struname,yytext);
  691.                         else struname[0]='\0';
  692.                         BEGIN(ins);
  693.                         }
  694.     YY_BREAK
  695. case 5:
  696. YY_RULE_SETUP
  697. #line 41 "head.l"
  698. {
  699.                         BEGIN(INITIAL);
  700.                         }
  701.     YY_BREAK
  702. case 6:
  703. YY_RULE_SETUP
  704. #line 44 "head.l"
  705.  
  706.     YY_BREAK
  707. case 7:
  708. YY_RULE_SETUP
  709. #line 45 "head.l"
  710. { lineno++; }
  711.     YY_BREAK
  712. case 8:
  713. YY_RULE_SETUP
  714. #line 46 "head.l"
  715. {
  716.                         if(struname[0]!='\0') {
  717.                             AddFunc(actfile,struname,struline);
  718.                         }
  719.                         BEGIN(INITIAL);
  720.                         }
  721.     YY_BREAK
  722. case 9:
  723. YY_RULE_SETUP
  724. #line 52 "head.l"
  725. { ++lineno; BEGIN(INITIAL); }
  726.     YY_BREAK
  727. case 10:
  728. YY_RULE_SETUP
  729. #line 53 "head.l"
  730. { BEGIN(INITIAL); }
  731.     YY_BREAK
  732. case 11:
  733. YY_RULE_SETUP
  734. #line 55 "head.l"
  735. { ++lineno; }
  736.     YY_BREAK
  737. case 12:
  738. YY_RULE_SETUP
  739. #line 56 "head.l"
  740.  
  741.     YY_BREAK
  742. case 13:
  743. YY_RULE_SETUP
  744. #line 58 "head.l"
  745. ECHO;
  746.     YY_BREAK
  747. case YY_STATE_EOF(INITIAL):
  748. case YY_STATE_EOF(xdefine):
  749. case YY_STATE_EOF(xstruct):
  750. case YY_STATE_EOF(ins):
  751.     yyterminate();
  752.  
  753.     case YY_END_OF_BUFFER:
  754.         {
  755.         /* Amount of text matched not including the EOB char. */
  756.         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  757.  
  758.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  759.         *yy_cp = yy_hold_char;
  760.         YY_RESTORE_YY_MORE_OFFSET
  761.  
  762.         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  763.             {
  764.             /* We're scanning a new file or input source.  It's
  765.              * possible that this happened because the user
  766.              * just pointed yyin at a new source and called
  767.              * yylex().  If so, then we have to assure
  768.              * consistency between yy_current_buffer and our
  769.              * globals.  Here is the right place to do so, because
  770.              * this is the first action (other than possibly a
  771.              * back-up) that will match for the new input source.
  772.              */
  773.             yy_n_chars = yy_current_buffer->yy_n_chars;
  774.             yy_current_buffer->yy_input_file = yyin;
  775.             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  776.             }
  777.  
  778.         /* Note that here we test for yy_c_buf_p "<=" to the position
  779.          * of the first EOB in the buffer, since yy_c_buf_p will
  780.          * already have been incremented past the NUL character
  781.          * (since all states make transitions on EOB to the
  782.          * end-of-buffer state).  Contrast this with the test
  783.          * in input().
  784.          */
  785.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  786.             { /* This was really a NUL. */
  787.             yy_state_type yy_next_state;
  788.  
  789.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  790.  
  791.             yy_current_state = yy_get_previous_state();
  792.  
  793.             /* Okay, we're now positioned to make the NUL
  794.              * transition.  We couldn't have
  795.              * yy_get_previous_state() go ahead and do it
  796.              * for us because it doesn't know how to deal
  797.              * with the possibility of jamming (and we don't
  798.              * want to build jamming into it because then it
  799.              * will run more slowly).
  800.              */
  801.  
  802.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  803.  
  804.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  805.  
  806.             if ( yy_next_state )
  807.                 {
  808.                 /* Consume the NUL. */
  809.                 yy_cp = ++yy_c_buf_p;
  810.                 yy_current_state = yy_next_state;
  811.                 goto yy_match;
  812.                 }
  813.  
  814.             else
  815.                 {
  816.                 yy_cp = yy_c_buf_p;
  817.                 goto yy_find_action;
  818.                 }
  819.             }
  820.  
  821.         else switch ( yy_get_next_buffer() )
  822.             {
  823.             case EOB_ACT_END_OF_FILE:
  824.                 {
  825.                 yy_did_buffer_switch_on_eof = 0;
  826.  
  827.                 if ( yywrap() )
  828.                     {
  829.                     /* Note: because we've taken care in
  830.                      * yy_get_next_buffer() to have set up
  831.                      * yytext, we can now set up
  832.                      * yy_c_buf_p so that if some total
  833.                      * hoser (like flex itself) wants to
  834.                      * call the scanner after we return the
  835.                      * YY_NULL, it'll still work - another
  836.                      * YY_NULL will get returned.
  837.                      */
  838.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  839.  
  840.                     yy_act = YY_STATE_EOF(YY_START);
  841.                     goto do_action;
  842.                     }
  843.  
  844.                 else
  845.                     {
  846.                     if ( ! yy_did_buffer_switch_on_eof )
  847.                         YY_NEW_FILE;
  848.                     }
  849.                 break;
  850.                 }
  851.  
  852.             case EOB_ACT_CONTINUE_SCAN:
  853.                 yy_c_buf_p =
  854.                     yytext_ptr + yy_amount_of_matched_text;
  855.  
  856.                 yy_current_state = yy_get_previous_state();
  857.  
  858.                 yy_cp = yy_c_buf_p;
  859.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  860.                 goto yy_match;
  861.  
  862.             case EOB_ACT_LAST_MATCH:
  863.                 yy_c_buf_p =
  864.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  865.  
  866.                 yy_current_state = yy_get_previous_state();
  867.  
  868.                 yy_cp = yy_c_buf_p;
  869.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  870.                 goto yy_find_action;
  871.             }
  872.         break;
  873.         }
  874.  
  875.     default:
  876.         YY_FATAL_ERROR(
  877.             "fatal flex scanner internal error--no action found" );
  878.     } /* end of action switch */
  879.         } /* end of scanning one token */
  880.     } /* end of yylex */
  881.  
  882.  
  883. /* yy_get_next_buffer - try to read in a new buffer
  884.  *
  885.  * Returns a code representing an action:
  886.  *    EOB_ACT_LAST_MATCH -
  887.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  888.  *    EOB_ACT_END_OF_FILE - end of file
  889.  */
  890.  
  891. static int yy_get_next_buffer()
  892.     {
  893.     register char *dest = yy_current_buffer->yy_ch_buf;
  894.     register char *source = yytext_ptr;
  895.     register int number_to_move, i;
  896.     int ret_val;
  897.  
  898.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  899.         YY_FATAL_ERROR(
  900.         "fatal flex scanner internal error--end of buffer missed" );
  901.  
  902.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  903.         { /* Don't try to fill the buffer, so this is an EOF. */
  904.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  905.             {
  906.             /* We matched a single character, the EOB, so
  907.              * treat this as a final EOF.
  908.              */
  909.             return EOB_ACT_END_OF_FILE;
  910.             }
  911.  
  912.         else
  913.             {
  914.             /* We matched some text prior to the EOB, first
  915.              * process it.
  916.              */
  917.             return EOB_ACT_LAST_MATCH;
  918.             }
  919.         }
  920.  
  921.     /* Try to read more data. */
  922.  
  923.     /* First move last chars to start of buffer. */
  924.     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  925.  
  926.     for ( i = 0; i < number_to_move; ++i )
  927.         *(dest++) = *(source++);
  928.  
  929.     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  930.         /* don't do the read, it's not guaranteed to return an EOF,
  931.          * just force an EOF
  932.          */
  933.         yy_current_buffer->yy_n_chars = yy_n_chars = 0;
  934.  
  935.     else
  936.         {
  937.         int num_to_read =
  938.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  939.  
  940.         while ( num_to_read <= 0 )
  941.             { /* Not enough room in the buffer - grow it. */
  942. #ifdef YY_USES_REJECT
  943.             YY_FATAL_ERROR(
  944. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  945. #else
  946.  
  947.             /* just a shorter name for the current buffer */
  948.             YY_BUFFER_STATE b = yy_current_buffer;
  949.  
  950.             int yy_c_buf_p_offset =
  951.                 (int) (yy_c_buf_p - b->yy_ch_buf);
  952.  
  953.             if ( b->yy_is_our_buffer )
  954.                 {
  955.                 int new_size = b->yy_buf_size * 2;
  956.  
  957.                 if ( new_size <= 0 )
  958.                     b->yy_buf_size += b->yy_buf_size / 8;
  959.                 else
  960.                     b->yy_buf_size *= 2;
  961.  
  962.                 b->yy_ch_buf = (char *)
  963.                     /* Include room in for 2 EOB chars. */
  964.                     yy_flex_realloc( (void *) b->yy_ch_buf,
  965.                              b->yy_buf_size + 2 );
  966.                 }
  967.             else
  968.                 /* Can't grow it, we don't own it. */
  969.                 b->yy_ch_buf = 0;
  970.  
  971.             if ( ! b->yy_ch_buf )
  972.                 YY_FATAL_ERROR(
  973.                 "fatal error - scanner input buffer overflow" );
  974.  
  975.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  976.  
  977.             num_to_read = yy_current_buffer->yy_buf_size -
  978.                         number_to_move - 1;
  979. #endif
  980.             }
  981.  
  982.         if ( num_to_read > YY_READ_BUF_SIZE )
  983.             num_to_read = YY_READ_BUF_SIZE;
  984.  
  985.         /* Read in more data. */
  986.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  987.             yy_n_chars, num_to_read );
  988.  
  989.         yy_current_buffer->yy_n_chars = yy_n_chars;
  990.         }
  991.  
  992.     if ( yy_n_chars == 0 )
  993.         {
  994.         if ( number_to_move == YY_MORE_ADJ )
  995.             {
  996.             ret_val = EOB_ACT_END_OF_FILE;
  997.             yyrestart( yyin );
  998.             }
  999.  
  1000.         else
  1001.             {
  1002.             ret_val = EOB_ACT_LAST_MATCH;
  1003.             yy_current_buffer->yy_buffer_status =
  1004.                 YY_BUFFER_EOF_PENDING;
  1005.             }
  1006.         }
  1007.  
  1008.     else
  1009.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1010.  
  1011.     yy_n_chars += number_to_move;
  1012.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1013.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1014.  
  1015.     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1016.  
  1017.     return ret_val;
  1018.     }
  1019.  
  1020.  
  1021. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1022.  
  1023. static yy_state_type yy_get_previous_state()
  1024.     {
  1025.     register yy_state_type yy_current_state;
  1026.     register char *yy_cp;
  1027.  
  1028.     yy_current_state = yy_start;
  1029.  
  1030.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1031.         {
  1032.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1033.         if ( yy_accept[yy_current_state] )
  1034.             {
  1035.             yy_last_accepting_state = yy_current_state;
  1036.             yy_last_accepting_cpos = yy_cp;
  1037.             }
  1038.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1039.             {
  1040.             yy_current_state = (int) yy_def[yy_current_state];
  1041.             if ( yy_current_state >= 44 )
  1042.                 yy_c = yy_meta[(unsigned int) yy_c];
  1043.             }
  1044.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1045.         }
  1046.  
  1047.     return yy_current_state;
  1048.     }
  1049.  
  1050.  
  1051. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1052.  *
  1053.  * synopsis
  1054.  *    next_state = yy_try_NUL_trans( current_state );
  1055.  */
  1056.  
  1057. #ifdef YY_USE_PROTOS
  1058. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1059. #else
  1060. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1061. yy_state_type yy_current_state;
  1062. #endif
  1063.     {
  1064.     register int yy_is_jam;
  1065.     register char *yy_cp = yy_c_buf_p;
  1066.  
  1067.     register YY_CHAR yy_c = 1;
  1068.     if ( yy_accept[yy_current_state] )
  1069.         {
  1070.         yy_last_accepting_state = yy_current_state;
  1071.         yy_last_accepting_cpos = yy_cp;
  1072.         }
  1073.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1074.         {
  1075.         yy_current_state = (int) yy_def[yy_current_state];
  1076.         if ( yy_current_state >= 44 )
  1077.             yy_c = yy_meta[(unsigned int) yy_c];
  1078.         }
  1079.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1080.     yy_is_jam = (yy_current_state == 43);
  1081.  
  1082.     return yy_is_jam ? 0 : yy_current_state;
  1083.     }
  1084.  
  1085.  
  1086. #ifndef YY_NO_UNPUT
  1087. #ifdef YY_USE_PROTOS
  1088. static void yyunput( int c, register char *yy_bp )
  1089. #else
  1090. static void yyunput( c, yy_bp )
  1091. int c;
  1092. register char *yy_bp;
  1093. #endif
  1094.     {
  1095.     register char *yy_cp = yy_c_buf_p;
  1096.  
  1097.     /* undo effects of setting up yytext */
  1098.     *yy_cp = yy_hold_char;
  1099.  
  1100.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1101.         { /* need to shift things up to make room */
  1102.         /* +2 for EOB chars. */
  1103.         register int number_to_move = yy_n_chars + 2;
  1104.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1105.                     yy_current_buffer->yy_buf_size + 2];
  1106.         register char *source =
  1107.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1108.  
  1109.         while ( source > yy_current_buffer->yy_ch_buf )
  1110.             *--dest = *--source;
  1111.  
  1112.         yy_cp += (int) (dest - source);
  1113.         yy_bp += (int) (dest - source);
  1114.         yy_current_buffer->yy_n_chars =
  1115.             yy_n_chars = yy_current_buffer->yy_buf_size;
  1116.  
  1117.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1118.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1119.         }
  1120.  
  1121.     *--yy_cp = (char) c;
  1122.  
  1123.  
  1124.     yytext_ptr = yy_bp;
  1125.     yy_hold_char = *yy_cp;
  1126.     yy_c_buf_p = yy_cp;
  1127.     }
  1128. #endif    /* ifndef YY_NO_UNPUT */
  1129.  
  1130.  
  1131. #ifdef __cplusplus
  1132. static int yyinput()
  1133. #else
  1134. static int input()
  1135. #endif
  1136.     {
  1137.     int c;
  1138.  
  1139.     *yy_c_buf_p = yy_hold_char;
  1140.  
  1141.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1142.         {
  1143.         /* yy_c_buf_p now points to the character we want to return.
  1144.          * If this occurs *before* the EOB characters, then it's a
  1145.          * valid NUL; if not, then we've hit the end of the buffer.
  1146.          */
  1147.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1148.             /* This was really a NUL. */
  1149.             *yy_c_buf_p = '\0';
  1150.  
  1151.         else
  1152.             { /* need more input */
  1153.             int offset = yy_c_buf_p - yytext_ptr;
  1154.             ++yy_c_buf_p;
  1155.  
  1156.             switch ( yy_get_next_buffer() )
  1157.                 {
  1158.                 case EOB_ACT_LAST_MATCH:
  1159.                     /* This happens because yy_g_n_b()
  1160.                      * sees that we've accumulated a
  1161.                      * token and flags that we need to
  1162.                      * try matching the token before
  1163.                      * proceeding.  But for input(),
  1164.                      * there's no matching to consider.
  1165.                      * So convert the EOB_ACT_LAST_MATCH
  1166.                      * to EOB_ACT_END_OF_FILE.
  1167.                      */
  1168.  
  1169.                     /* Reset buffer status. */
  1170.                     yyrestart( yyin );
  1171.  
  1172.                     /* fall through */
  1173.  
  1174.                 case EOB_ACT_END_OF_FILE:
  1175.                     {
  1176.                     if ( yywrap() )
  1177.                         return EOF;
  1178.  
  1179.                     if ( ! yy_did_buffer_switch_on_eof )
  1180.                         YY_NEW_FILE;
  1181. #ifdef __cplusplus
  1182.                     return yyinput();
  1183. #else
  1184.                     return input();
  1185. #endif
  1186.                     }
  1187.  
  1188.                 case EOB_ACT_CONTINUE_SCAN:
  1189.                     yy_c_buf_p = yytext_ptr + offset;
  1190.                     break;
  1191.                 }
  1192.             }
  1193.         }
  1194.  
  1195.     c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  1196.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1197.     yy_hold_char = *++yy_c_buf_p;
  1198.  
  1199.  
  1200.     return c;
  1201.     }
  1202.  
  1203.  
  1204. #ifdef YY_USE_PROTOS
  1205. void yyrestart( FILE *input_file )
  1206. #else
  1207. void yyrestart( input_file )
  1208. FILE *input_file;
  1209. #endif
  1210.     {
  1211.     if ( ! yy_current_buffer )
  1212.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1213.  
  1214.     yy_init_buffer( yy_current_buffer, input_file );
  1215.     yy_load_buffer_state();
  1216.     }
  1217.  
  1218.  
  1219. #ifdef YY_USE_PROTOS
  1220. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1221. #else
  1222. void yy_switch_to_buffer( new_buffer )
  1223. YY_BUFFER_STATE new_buffer;
  1224. #endif
  1225.     {
  1226.     if ( yy_current_buffer == new_buffer )
  1227.         return;
  1228.  
  1229.     if ( yy_current_buffer )
  1230.         {
  1231.         /* Flush out information for old buffer. */
  1232.         *yy_c_buf_p = yy_hold_char;
  1233.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1234.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1235.         }
  1236.  
  1237.     yy_current_buffer = new_buffer;
  1238.     yy_load_buffer_state();
  1239.  
  1240.     /* We don't actually know whether we did this switch during
  1241.      * EOF (yywrap()) processing, but the only time this flag
  1242.      * is looked at is after yywrap() is called, so it's safe
  1243.      * to go ahead and always set it.
  1244.      */
  1245.     yy_did_buffer_switch_on_eof = 1;
  1246.     }
  1247.  
  1248.  
  1249. #ifdef YY_USE_PROTOS
  1250. void yy_load_buffer_state( void )
  1251. #else
  1252. void yy_load_buffer_state()
  1253. #endif
  1254.     {
  1255.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1256.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1257.     yyin = yy_current_buffer->yy_input_file;
  1258.     yy_hold_char = *yy_c_buf_p;
  1259.     }
  1260.  
  1261.  
  1262. #ifdef YY_USE_PROTOS
  1263. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1264. #else
  1265. YY_BUFFER_STATE yy_create_buffer( file, size )
  1266. FILE *file;
  1267. int size;
  1268. #endif
  1269.     {
  1270.     YY_BUFFER_STATE b;
  1271.  
  1272.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1273.     if ( ! b )
  1274.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1275.  
  1276.     b->yy_buf_size = size;
  1277.  
  1278.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1279.      * we need to put in 2 end-of-buffer characters.
  1280.      */
  1281.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1282.     if ( ! b->yy_ch_buf )
  1283.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1284.  
  1285.     b->yy_is_our_buffer = 1;
  1286.  
  1287.     yy_init_buffer( b, file );
  1288.  
  1289.     return b;
  1290.     }
  1291.  
  1292.  
  1293. #ifdef YY_USE_PROTOS
  1294. void yy_delete_buffer( YY_BUFFER_STATE b )
  1295. #else
  1296. void yy_delete_buffer( b )
  1297. YY_BUFFER_STATE b;
  1298. #endif
  1299.     {
  1300.     if ( ! b )
  1301.         return;
  1302.  
  1303.     if ( b == yy_current_buffer )
  1304.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1305.  
  1306.     if ( b->yy_is_our_buffer )
  1307.         yy_flex_free( (void *) b->yy_ch_buf );
  1308.  
  1309.     yy_flex_free( (void *) b );
  1310.     }
  1311.  
  1312.  
  1313. #ifndef YY_ALWAYS_INTERACTIVE
  1314. #ifndef YY_NEVER_INTERACTIVE
  1315. extern int isatty YY_PROTO(( int ));
  1316. #endif
  1317. #endif
  1318.  
  1319. #ifdef YY_USE_PROTOS
  1320. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1321. #else
  1322. void yy_init_buffer( b, file )
  1323. YY_BUFFER_STATE b;
  1324. FILE *file;
  1325. #endif
  1326.  
  1327.  
  1328.     {
  1329.     yy_flush_buffer( b );
  1330.  
  1331.     b->yy_input_file = file;
  1332.     b->yy_fill_buffer = 1;
  1333.  
  1334. #if YY_ALWAYS_INTERACTIVE
  1335.     b->yy_is_interactive = 1;
  1336. #else
  1337. #if YY_NEVER_INTERACTIVE
  1338.     b->yy_is_interactive = 0;
  1339. #else
  1340.     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1341. #endif
  1342. #endif
  1343.     }
  1344.  
  1345.  
  1346. #ifdef YY_USE_PROTOS
  1347. void yy_flush_buffer( YY_BUFFER_STATE b )
  1348. #else
  1349. void yy_flush_buffer( b )
  1350. YY_BUFFER_STATE b;
  1351. #endif
  1352.  
  1353.     {
  1354.     if ( ! b )
  1355.         return;
  1356.  
  1357.     b->yy_n_chars = 0;
  1358.  
  1359.     /* We always need two end-of-buffer characters.  The first causes
  1360.      * a transition to the end-of-buffer state.  The second causes
  1361.      * a jam in that state.
  1362.      */
  1363.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1364.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1365.  
  1366.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1367.  
  1368.     b->yy_at_bol = 1;
  1369.     b->yy_buffer_status = YY_BUFFER_NEW;
  1370.  
  1371.     if ( b == yy_current_buffer )
  1372.         yy_load_buffer_state();
  1373.     }
  1374.  
  1375.  
  1376. #ifndef YY_NO_SCAN_BUFFER
  1377. #ifdef YY_USE_PROTOS
  1378. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1379. #else
  1380. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1381. char *base;
  1382. yy_size_t size;
  1383. #endif
  1384.     {
  1385.     YY_BUFFER_STATE b;
  1386.  
  1387.     if ( size < 2 ||
  1388.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1389.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  1390.         /* They forgot to leave room for the EOB's. */
  1391.         return 0;
  1392.  
  1393.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1394.     if ( ! b )
  1395.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  1396.  
  1397.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  1398.     b->yy_buf_pos = b->yy_ch_buf = base;
  1399.     b->yy_is_our_buffer = 0;
  1400.     b->yy_input_file = 0;
  1401.     b->yy_n_chars = b->yy_buf_size;
  1402.     b->yy_is_interactive = 0;
  1403.     b->yy_at_bol = 1;
  1404.     b->yy_fill_buffer = 0;
  1405.     b->yy_buffer_status = YY_BUFFER_NEW;
  1406.  
  1407.     yy_switch_to_buffer( b );
  1408.  
  1409.     return b;
  1410.     }
  1411. #endif
  1412.  
  1413.  
  1414. #ifndef YY_NO_SCAN_STRING
  1415. #ifdef YY_USE_PROTOS
  1416. YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
  1417. #else
  1418. YY_BUFFER_STATE yy_scan_string( yy_str )
  1419. yyconst char *yy_str;
  1420. #endif
  1421.     {
  1422.     int len;
  1423.     for ( len = 0; yy_str[len]; ++len )
  1424.         ;
  1425.  
  1426.     return yy_scan_bytes( yy_str, len );
  1427.     }
  1428. #endif
  1429.  
  1430.  
  1431. #ifndef YY_NO_SCAN_BYTES
  1432. #ifdef YY_USE_PROTOS
  1433. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  1434. #else
  1435. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  1436. yyconst char *bytes;
  1437. int len;
  1438. #endif
  1439.     {
  1440.     YY_BUFFER_STATE b;
  1441.     char *buf;
  1442.     yy_size_t n;
  1443.     int i;
  1444.  
  1445.     /* Get memory for full buffer, including space for trailing EOB's. */
  1446.     n = len + 2;
  1447.     buf = (char *) yy_flex_alloc( n );
  1448.     if ( ! buf )
  1449.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  1450.  
  1451.     for ( i = 0; i < len; ++i )
  1452.         buf[i] = bytes[i];
  1453.  
  1454.     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  1455.  
  1456.     b = yy_scan_buffer( buf, n );
  1457.     if ( ! b )
  1458.         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  1459.  
  1460.     /* It's okay to grow etc. this buffer, and we should throw it
  1461.      * away when we're done.
  1462.      */
  1463.     b->yy_is_our_buffer = 1;
  1464.  
  1465.     return b;
  1466.     }
  1467. #endif
  1468.  
  1469.  
  1470. #ifndef YY_NO_PUSH_STATE
  1471. #ifdef YY_USE_PROTOS
  1472. static void yy_push_state( int new_state )
  1473. #else
  1474. static void yy_push_state( new_state )
  1475. int new_state;
  1476. #endif
  1477.     {
  1478.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1479.         {
  1480.         yy_size_t new_size;
  1481.  
  1482.         yy_start_stack_depth += YY_START_STACK_INCR;
  1483.         new_size = yy_start_stack_depth * sizeof( int );
  1484.  
  1485.         if ( ! yy_start_stack )
  1486.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1487.  
  1488.         else
  1489.             yy_start_stack = (int *) yy_flex_realloc(
  1490.                     (void *) yy_start_stack, new_size );
  1491.  
  1492.         if ( ! yy_start_stack )
  1493.             YY_FATAL_ERROR(
  1494.             "out of memory expanding start-condition stack" );
  1495.         }
  1496.  
  1497.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1498.  
  1499.     BEGIN(new_state);
  1500.     }
  1501. #endif
  1502.  
  1503.  
  1504. #ifndef YY_NO_POP_STATE
  1505. static void yy_pop_state()
  1506.     {
  1507.     if ( --yy_start_stack_ptr < 0 )
  1508.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1509.  
  1510.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1511.     }
  1512. #endif
  1513.  
  1514.  
  1515. #ifndef YY_NO_TOP_STATE
  1516. static int yy_top_state()
  1517.     {
  1518.     return yy_start_stack[yy_start_stack_ptr - 1];
  1519.     }
  1520. #endif
  1521.  
  1522. #ifndef YY_EXIT_FAILURE
  1523. #define YY_EXIT_FAILURE 2
  1524. #endif
  1525.  
  1526. #ifdef YY_USE_PROTOS
  1527. static void yy_fatal_error( yyconst char msg[] )
  1528. #else
  1529. static void yy_fatal_error( msg )
  1530. char msg[];
  1531. #endif
  1532.     {
  1533.     (void) fprintf( stderr, "%s\n", msg );
  1534.     exit( YY_EXIT_FAILURE );
  1535.     }
  1536.  
  1537.  
  1538.  
  1539. /* Redefine yyless() so it works in section 3 code. */
  1540.  
  1541. #undef yyless
  1542. #define yyless(n) \
  1543.     do \
  1544.         { \
  1545.         /* Undo effects of setting up yytext. */ \
  1546.         yytext[yyleng] = yy_hold_char; \
  1547.         yy_c_buf_p = yytext + n; \
  1548.         yy_hold_char = *yy_c_buf_p; \
  1549.         *yy_c_buf_p = '\0'; \
  1550.         yyleng = n; \
  1551.         } \
  1552.     while ( 0 )
  1553.  
  1554.  
  1555. /* Internal utility routines. */
  1556.  
  1557. #ifndef yytext_ptr
  1558. #ifdef YY_USE_PROTOS
  1559. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  1560. #else
  1561. static void yy_flex_strncpy( s1, s2, n )
  1562. char *s1;
  1563. yyconst char *s2;
  1564. int n;
  1565. #endif
  1566.     {
  1567.     register int i;
  1568.     for ( i = 0; i < n; ++i )
  1569.         s1[i] = s2[i];
  1570.     }
  1571. #endif
  1572.  
  1573. #ifdef YY_NEED_STRLEN
  1574. #ifdef YY_USE_PROTOS
  1575. static int yy_flex_strlen( yyconst char *s )
  1576. #else
  1577. static int yy_flex_strlen( s )
  1578. yyconst char *s;
  1579. #endif
  1580.     {
  1581.     register int n;
  1582.     for ( n = 0; s[n]; ++n )
  1583.         ;
  1584.  
  1585.     return n;
  1586.     }
  1587. #endif
  1588.  
  1589.  
  1590. #ifdef YY_USE_PROTOS
  1591. static void *yy_flex_alloc( yy_size_t size )
  1592. #else
  1593. static void *yy_flex_alloc( size )
  1594. yy_size_t size;
  1595. #endif
  1596.     {
  1597.     return (void *) malloc( size );
  1598.     }
  1599.  
  1600. #ifdef YY_USE_PROTOS
  1601. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  1602. #else
  1603. static void *yy_flex_realloc( ptr, size )
  1604. void *ptr;
  1605. yy_size_t size;
  1606. #endif
  1607.     {
  1608.     /* The cast to (char *) in the following accommodates both
  1609.      * implementations that use char* generic pointers, and those
  1610.      * that use void* generic pointers.  It works with the latter
  1611.      * because both ANSI C and C++ allow castless assignment from
  1612.      * any pointer type to void*, and deal with argument conversions
  1613.      * as though doing an assignment.
  1614.      */
  1615.     return (void *) realloc( (char *) ptr, size );
  1616.     }
  1617.  
  1618. #ifdef YY_USE_PROTOS
  1619. static void yy_flex_free( void *ptr )
  1620. #else
  1621. static void yy_flex_free( ptr )
  1622. void *ptr;
  1623. #endif
  1624.     {
  1625.     free( ptr );
  1626.     }
  1627.  
  1628. #if YY_MAIN
  1629. int main()
  1630.     {
  1631.     yylex();
  1632.     return 0;
  1633.     }
  1634. #endif
  1635. #line 58 "head.l"
  1636.  
  1637.  
  1638. void scanhead(char *file) {
  1639.     FILE *f;
  1640.  
  1641.     actfile=file;
  1642.     lineno=1;
  1643.     if(NULL==(yyin=f=fopen(file,"rb"))) return;
  1644.     yylex();
  1645.     fclose(f);
  1646. }
  1647.  
  1648.